# recursive_splitter_demo.py
from langchain.text_splitter import RecursiveCharacterTextSplitter
from typing import List, Dict, Any
import re


def demonstrate_recursive_splitter():
    """演示递归字符分割器"""

    print("✂️ 递归字符分割器演示")
    print("=" * 25)

    # 多种类型的文档示例
    documents = {
        "简历文档": """
张工程师简历

基本信息：
姓名：张工程师，年龄：30岁，电话：13800138000
工作地点：北京，邮箱：zhang@email.com

技能专长：
• Python开发（5年经验）
• Django/Flask框架
• MySQL/Redis数据库
• Docker容器化技术
• AWS云服务

工作经历：
2019-2024年 阿里巴巴集团 高级Python开发工程师
主要职责：负责电商核心系统开发，使用Python+Django技术栈。
技术亮点：系统性能优化，QPS提升300%；分布式架构设计；微服务拆分。
团队管理：带领5人开发团队，完成多个重要项目。

2017-2019年 腾讯科技 Python开发工程师  
主要职责：微信支付系统开发，负责后端API设计和实现。
技术成果：支付成功率提升到99.95%；接口响应时间优化到50ms以内。
""",

        "职位描述": """
高级Python开发工程师

公司简介：
我们是一家快速发展的互联网公司，专注于人工智能和大数据技术。

职位职责：
1. 负责后端系统开发和维护
2. 参与系统架构设计和优化
3. 编写高质量的代码和文档
4. 指导初级开发人员

任职要求：
• 5年以上Python开发经验
• 精通Django或Flask框架
• 熟悉MySQL、Redis等数据库
• 具备分布式系统开发经验
• 良好的团队协作能力

薪资福利：
薪资范围：25K-40K，根据能力面议
福利待遇：五险一金、股权激励、弹性工作、技术培训
""",

        "面试记录": """
面试官：请介绍一下您的工作经验。

候选人：我有5年的Python开发经验，主要在阿里巴巴和腾讯工作。在阿里负责电商系统开发，使用Django框架；在腾讯参与微信支付系统开发。

面试官：您在项目中遇到过什么技术难题？是如何解决的？

候选人：在电商系统中，我们遇到了高并发问题。我通过引入Redis缓存、数据库读写分离、以及异步处理来解决。最终系统QPS从1000提升到4000。

面试官：对我们公司有什么了解？为什么想加入我们？

候选人：贵公司在AI领域很有影响力，我希望能参与到更有挑战性的项目中，发挥我在后端开发方面的经验。
"""
    }

    # 1. 基础递归分割演示
    print("1️⃣ 基础递归分割：")

    # 创建递归分割器
    recursive_splitter = RecursiveCharacterTextSplitter(
        chunk_size=300,
        chunk_overlap=50,
        separators=["\n\n", "\n", "。", "；", "，", " "]
    )

    for doc_name, content in documents.items():
        print(f"\n   {doc_name}:")
        chunks = recursive_splitter.split_text(content)

        print(f"   原文: {len(content)}字符")
        print(f"   分割: {len(chunks)}块")

        for i, chunk in enumerate(chunks[:2], 1):
            preview = chunk[:50].replace('\n', ' ').strip()
            print(f"   块{i}: {preview}...")

    # 2. 分隔符优先级演示
    print("\n2️⃣ 分隔符优先级演示：")

    test_text = """
第一段落内容。这是一个完整的段落。

第二段落内容；包含分号分隔的内容；还有更多内容。

第三段落，包含逗号分隔，的短语，和更多，内容。
"""

    # 不同的分隔符配置
    separator_configs = {
        "标准配置": ["\n\n", "\n", "。", "；", "，", " "],
        "段落优先": ["\n\n", "。", "\n", "；", "，", " "],
        "句子优先": ["。", "；", "\n\n", "\n", "，", " "],
        "简单配置": ["\n", " "]
    }

    for config_name, separators in separator_configs.items():
        splitter = RecursiveCharacterTextSplitter(
            chunk_size=150,
            chunk_overlap=20,
            separators=separators
        )

        chunks = splitter.split_text(test_text)
        print(f"\n   {config_name}:")
        print(f"   分隔符: {separators}")
        print(f"   结果: {len(chunks)}块")

        for i, chunk in enumerate(chunks, 1):
            clean_chunk = chunk.strip().replace('\n', '\\n')
            print(f"     块{i}: {clean_chunk}")

    # 3. 参数优化演示
    print("\n3️⃣ 参数优化演示：")

    optimization_configs = [
        {"chunk_size": 200, "overlap": 20, "name": "小块低重叠"},
        {"chunk_size": 200, "overlap": 50, "name": "小块高重叠"},
        {"chunk_size": 500, "overlap": 50, "name": "大块低重叠"},
        {"chunk_size": 500, "overlap": 100, "name": "大块高重叠"}
    ]

    sample_doc = documents["简历文档"]

    for config in optimization_configs:
        splitter = RecursiveCharacterTextSplitter(
            chunk_size=config["chunk_size"],
            chunk_overlap=config["overlap"],
            separators=["\n\n", "\n", "。", "；", "，", " "]
        )

        chunks = splitter.split_text(sample_doc)

        # 计算质量指标
        quality_metrics = calculate_splitting_quality(chunks, sample_doc)

        print(f"\n   {config['name']}:")
        print(f"   配置: 块大小{config['chunk_size']}, 重叠{config['overlap']}")
        print(f"   结果: {len(chunks)}块")
        print(f"   质量评分: {quality_metrics['overall_score']:.2f}/10")
        print(f"   长度方差: {quality_metrics['length_variance']:.0f}")
        print(f"   语义完整性: {quality_metrics['semantic_completeness']:.2f}")


def calculate_splitting_quality(chunks: List[str], original_text: str) -> Dict[str, float]:
    """计算分割质量指标"""

    if not chunks:
        return {"overall_score": 0, "length_variance": 0, "semantic_completeness": 0}

    # 1. 长度一致性
    lengths = [len(chunk) for chunk in chunks]
    avg_length = sum(lengths) / len(lengths)
    length_variance = sum((l - avg_length) ** 2 for l in lengths) / len(lengths)

    # 2. 语义完整性（简化评估）
    semantic_score = 0
    for chunk in chunks:
        # 检查是否以完整的语法单位结束
        chunk_stripped = chunk.strip()
        if chunk_stripped.endswith(('。', '！', '？', '：', '\n')):
            semantic_score += 1

        # 检查是否包含完整的信息单元
        if any(keyword in chunk for keyword in ['工作', '技能', '项目', '教育', '经验']):
            semantic_score += 0.5

    semantic_completeness = semantic_score / len(chunks)

    # 3. 信息保持完整性
    total_chunk_length = sum(len(chunk) for chunk in chunks)
    completeness_ratio = total_chunk_length / len(original_text)

    # 综合评分
    length_score = max(0, 10 - length_variance / 1000)  # 长度方差越小越好
    semantic_score_norm = semantic_completeness * 10  # 语义完整性
    completeness_score = completeness_ratio * 10  # 信息完整性

    overall_score = (length_score + semantic_score_norm + completeness_score) / 3

    return {
        "overall_score": min(overall_score, 10),
        "length_variance": length_variance,
        "semantic_completeness": semantic_completeness,
        "completeness_ratio": completeness_ratio
    }


def demonstrate_advanced_recursive_splitting():
    """演示高级递归分割技术"""

    print("\n4️⃣ 高级递归分割技术：")

    # 复杂文档示例
    complex_document = """
# 技术方案文档

## 1. 系统架构

### 1.1 整体架构
我们采用微服务架构，包括以下组件：
- API网关：负责请求路由和认证
- 用户服务：处理用户管理相关功能
- 订单服务：处理订单创建和管理
- 支付服务：集成第三方支付接口

### 1.2 技术栈选择
后端技术栈：
```python
# 主要框架
Django + DRF
Redis + Celery
PostgreSQL + MongoDB
Docker + Kubernetes
    """
